home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Camelot / Camelot 134 (1991-10)(Swedish User Group of Amiga)(SE)(PD)[WB].zip / Camelot 134 (1991-10)(Swedish User Group of Amiga)(SE)(PD)[WB].adf / RxSlides / RxSlidesDs.c < prev    next >
C/C++ Source or Header  |  1990-03-08  |  6KB  |  255 lines
  1. /* :bk=0 */
  2.  
  3. /****************************************************************/
  4. /*                                */
  5. /*    RxSlidesDs.c                        */
  6. /*                                */
  7. /* Author: Dean Bandes from Lee M. Robertson's "Dissolve"    */
  8. /****************************************************************/
  9.  
  10. #include "exec/types.h"
  11. #include "exec/memory.h"
  12. #include "graphics/gfx.h"
  13. #include "intuition/intuition.h"
  14. #include "storage.h"
  15. #include <stdio.h>
  16. #include "RxSlides.h"
  17. #include "RxSliPic.h"
  18.  
  19. void         *GetMsg();
  20. void         *AllocMem();
  21.  
  22. extern    struct    GfxBase        *GfxBase;
  23. extern    struct    IntuitionBase    *IntuitionBase;
  24.  
  25. /*---------------------------------------------------------------------------
  26.  *
  27.  *-------------------------------------------------------------------------*/
  28. get_message()
  29. {
  30.   extern struct Window *Window;
  31.  
  32.     register ULONG class;
  33.     register USHORT code;
  34.     register struct IntuiMessage *Message;
  35.     static int retval = 0;
  36.  
  37.     while( Message = (struct IntuiMessage *) GetMsg(Window->UserPort) )
  38.     {
  39.         class = Message->Class;
  40.         code  = Message->Code;
  41.         ReplyMsg(Message);
  42.  
  43.         /* allow any key press to end program */
  44.         if( class == CLOSEWINDOW || class == RAWKEY )
  45.             retval = 1;
  46.         /* allow user to hold program with right mouse button */
  47.         else if( class == MOUSEBUTTONS && code == MENUDOWN )
  48.             WaitPort( Window->UserPort);
  49.     }
  50.     return retval;
  51. }
  52.  
  53. /*---------------------------------------------------------------------------
  54.  * some global variables for the dissolve function
  55.  *-------------------------------------------------------------------------*/
  56. unsigned long rand_mask;    /* the mask value for the random # generator */
  57. unsigned long rand_val;        /* the current random # value */
  58. unsigned long rand_tbl[] =    /* the table of random mask values */
  59. {                /* from Nov '86 DDJ p. 48 */
  60.     0,0,            /* first 2 values don't work */
  61.     3,6,
  62.     0xc,0x14,
  63.     0x30,0x60,
  64.     0xb8,0x110,
  65.     0x240,0x500,
  66.     0xca0,0x1b00,
  67.     0x3500,0x6000,
  68.     0xb400,0x12000,
  69.     0x20400,0x72000,
  70.     0x90000,0x140000,
  71.     0x300000,0x420000,
  72.     0xd80000,0x1200000,
  73.     0x3880000,0x7200000,
  74.     0x9000000,0x14000000,
  75.     0x32800000,0x48000000,
  76.     0xa3000000                /* for 32 bits wide */
  77. };
  78.  
  79. /*---------------------------------------------------------------------------
  80.  * dissolve() -- dissolve one bitmap into another
  81.  *        this only works for full width bit maps
  82.  *-------------------------------------------------------------------------*/
  83. dissolve( src, dst, speed, transition )
  84. struct BitMap *src,*dst;
  85. LONG    speed;
  86. SHORT    transition;
  87. {
  88.   void fadecolors ();
  89.  
  90.   extern    UBYTE    svcmap[];
  91.   extern    SHORT    rmap_index;
  92.  
  93.   extern struct ViewPort *vp;
  94.   extern struct    picture   pic;
  95.  
  96.     register UBYTE *mplane;        /* the dissolve mask plane */
  97.     register long psize;        /* the size of a plane */
  98.     register long nbits;        /* # of bits in a plane */
  99.     register int done;
  100.     register int i;
  101.     register int j;
  102.     int     c;
  103.     int     k;
  104.     int     n_bits_set;
  105.     UBYTE   *bpt;
  106.  
  107.     psize = src->BytesPerRow * src->Rows;
  108.  
  109.     if( (mplane = (UBYTE *) AllocMem( psize, MEMF_CHIP | MEMF_CLEAR) ) == 0 )
  110.         return (STS_BAD_ALLOC);
  111.     bpt = mplane;
  112.  
  113.     switch (transition)
  114.         {
  115.         case DM_ZAP:
  116.         default:
  117.         bpt = mplane;
  118.         for ( i = psize; i--; )
  119.             *bpt++ = 0xFF;
  120.         setcolors (vp, &pic.cmap[0], pic.numcolors);
  121.         BlitBitMapMask (src, dst, mplane);
  122.         break;
  123.         case DM_TWIPE:
  124.         bpt = mplane;
  125.         n_bits_set = 0;
  126.         for ( i = psize; i--; )
  127.             {
  128.             *bpt++ = 0xFF;
  129.             if ( n_bits_set++ >= speed / 8 )
  130.             {
  131.             n_bits_set = 0;
  132.             fadecolors (vp, &svcmap[0], &pic.cmap[0],
  133.                     psize + 1 - i, psize, pic.numcolors);
  134.             BlitBitMapMask (src, dst, mplane);
  135.             }
  136.             }
  137.         setcolors (vp, &pic.cmap[0], pic.numcolors);
  138.         BlitBitMapMask (src, dst, mplane);
  139.         break;
  140.         case DM_BWIPE:
  141.         bpt = mplane + psize - 1;
  142.         n_bits_set = 0;
  143.         for ( i = psize; i--; )
  144.             {
  145.             *bpt-- = 0xFF;
  146.             if ( n_bits_set++ >= speed / 8 )
  147.             {
  148.             n_bits_set = 0;
  149.             fadecolors (vp, &svcmap[0], &pic.cmap[0],
  150.                     psize + 1 - i, psize, pic.numcolors);
  151.             BlitBitMapMask (src, dst, mplane);
  152.             }
  153.             }
  154.         setcolors (vp, &pic.cmap[0], pic.numcolors);
  155.         BlitBitMapMask (src, dst, mplane);
  156.         break;
  157.         case DM_LWIPE:
  158.         n_bits_set = 0;
  159.         for ( i=0; i<src->BytesPerRow; i++ )
  160.             {
  161.             for (k = 0, c = 0x80; k++ < 8; c = 0x80 | ( c >> 1 ) )
  162.             {
  163.             bpt = mplane + i;
  164.             for ( j=0; j<src->Rows; j++)
  165.                 {
  166.                 *bpt = (UBYTE) c;
  167.                 bpt += src->BytesPerRow;
  168.                 n_bits_set++;
  169.                 }
  170.             if (n_bits_set >= speed)
  171.                 {
  172.                 fadecolors (vp, &svcmap[0], &pic.cmap[0],
  173.                     i+1, src->BytesPerRow, pic.numcolors);
  174.                 BlitBitMapMask (src, dst, mplane);
  175.                 n_bits_set = 0;
  176.                 }
  177.             }
  178.             }
  179.         setcolors (vp, &pic.cmap[0], pic.numcolors);
  180.         BlitBitMapMask (src, dst, mplane);
  181.         break;
  182.         case DM_RWIPE:
  183.         n_bits_set = 0;
  184.         for ( i=0; i<src->BytesPerRow; i++ )
  185.             {
  186.             for (c = 1; c < 0x100; c = 1 | ( c << 1 ) )
  187.             {
  188.             bpt = mplane + psize - i;
  189.             for ( j=0; j<src->Rows; j++)
  190.                 {
  191.                 *bpt = (UBYTE) c;
  192.                 bpt -= src->BytesPerRow;
  193.                 n_bits_set++;
  194.                 }
  195.             if (n_bits_set >= speed)
  196.                 {
  197.                 fadecolors (vp, &svcmap[0], &pic.cmap[0],
  198.                     i+1, src->BytesPerRow, pic.numcolors);
  199.                 BlitBitMapMask (src, dst, mplane);
  200.                 n_bits_set = 0;
  201.                 }
  202.             }
  203.             }
  204.         setcolors (vp, &pic.cmap[0], pic.numcolors);
  205.         BlitBitMapMask (src, dst, mplane);
  206.         break;
  207.         case DM_VBLIN:
  208.         n_bits_set = 0;
  209.         for (k = 0, c = 0x80; k++ < 8; c = 0x80 | ( c >> 1 ) )
  210.             {
  211.             fadecolors (vp, &svcmap[0], &pic.cmap[0],
  212.                 k, 8, pic.numcolors);
  213.             for ( i=0; i<src->BytesPerRow; i++ )
  214.             {
  215.             bpt = mplane + i;
  216.             for ( j=0; j<src->Rows; j++)
  217.                 {
  218.                 *bpt = (UBYTE) c;
  219.                 bpt += src->BytesPerRow;
  220.                 n_bits_set++;
  221.                 }
  222.             if ( n_bits_set >= speed )
  223.                 BlitBitMapMask (src, dst, mplane);
  224.             }
  225.             }
  226.         setcolors (vp, &pic.cmap[0], pic.numcolors);
  227.         BlitBitMapMask (src, dst, mplane);
  228.         break;
  229.         case DM_DISSO:
  230.         nbits = psize << 3;
  231.         nbits--;            /* max bit is 1 less */
  232.  
  233.         /* initialize the random number generator */
  234.         rand_val = 1;
  235.         rand_mask = rand_tbl[ rmap_index /* bitwidth(nbits) */ ];
  236.         mplane[0] |= 1;            /* set the first bit in the mask plane */
  237.  
  238.         done = 0;        /* clear done flag */
  239.         i = 0;
  240.         while( done == 0 )
  241.         {
  242.             done = setbits( mplane, nbits, speed );
  243.             i += speed / 8;
  244.             fadecolors (vp, &svcmap[0], &pic.cmap[0],
  245.                     i, psize,
  246.                     pic.numcolors);
  247.             BlitBitMapMask( src, dst, mplane );
  248.         }
  249.  
  250.         }
  251.  
  252.     FreeMem( mplane, psize );
  253.     return (STS_OK);
  254. }
  255.